// 引入标准输入输出库，用于 printf、scanf 等输入输出函数
#include <stdio.h>
// 引入字符串处理库，用于 strcpy、strcmp 等字符串操作函数
#include <string.h>
// 引入标准库，用于 malloc、free 等内存管理函数（本代码未直接使用，但预留扩展）
#include <stdlib.h>

// 定义宏：最大寝室数量为 50
#define MAX_DORMS 50        
// 定义宏：每个寝室最大容纳学生数量为 6
#define MAX_STUDENTS_PER_DORM 6  

// 定义学生信息结构体（typedef 为 Stu_t，方便后续使用）
typedef struct Student {
    char num[11];   // 学号（最多10个字符，预留1位结束符）
    char name[20];  // 姓名（最多19个字符，预留1位结束符）
} Stu_t;

// 定义寝室信息结构体（typedef 为 Dorm_t，方便后续使用）
typedef struct Dormitory {
    char dormNum[6];    // 寝室号（最多5个字符，如301、402）
    char building[4];   // 楼栋（最多3个字符，如1栋、2栋）
    int capacity;       // 寝室容量（如4人、6人）
    int currentCount;   // 当前住宿人数
    // 住宿人员列表（数组大小为每个寝室最大人数）
    Stu_t members[MAX_STUDENTS_PER_DORM];  
    float cleanScore;   // 卫生评分（范围0-100）
    char status[10];    // 状态（如空闲/未满/满员/维修中，最多9个字符）
} Dorm_t;

// 全局变量：寝室数组（初始包含3个示例寝室）
Dorm_t dorms[MAX_DORMS] = {
    // 第一个寝室：301号，1栋，容量4人，当前2人，成员张三（1001）、李四（1002），卫生分90.5，状态未满
    {"301", "1", 4, 2, {{"1001", "张三"}, {"1002", "李四"}}, 90.5, "未满"},
    // 第二个寝室：402号，2栋，容量6人，当前6人（满员），卫生分85.0，状态满员
    {"402", "2", 6, 6, {{"2001", "王五"}, {"2002", "赵六"}, {"2003", "钱七"}, {"2004", "孙八"}, {"2005", "周九"}, {"2006", "吴十"}}, 85.0, "满员"},
    // 第三个寝室：203号，1栋，容量4人，当前0人，卫生分0.0，状态空闲
    {"203", "1", 4, 0, {}, 0.0, "空闲"}
};
// 全局变量：当前寝室总数（初始为3个）
int dormCount = 3;  

// 函数声明：清除输入缓冲区（避免残留输入影响后续操作）
void clearInputBuffer();
// 函数声明：显示所有寝室信息
void showAllDorms();
// 函数声明：判断寝室号是否存在（返回索引，不存在返回-1）
int isDormExist(char *dormNum);  

// 函数指针声明：主菜单函数（参数为void*，返回int）
int mainMenu(void *arg);
// 函数指针声明：菜单1（寝室信息管理）
int menu1(void *arg);  
// 函数指针声明：菜单2（住宿人员管理）
int menu2(void *arg);  
// 函数指针声明：菜单3（统计与查询）
int menu3(void *arg);  
// 函数指针声明：菜单4（文件操作）
int menu4(void *arg);  
// 定义函数指针变量currentMenu，用于动态切换当前菜单
int (*currentMenu)(void *);

// 核心功能函数声明：添加寝室
void addDorm();       
// 核心功能函数声明：修改寝室信息
void updateDorm();    
// 核心功能函数声明：删除寝室
void deleteDorm();    
// 核心功能函数声明：新增住宿人员
void addMember();     
// 核心功能函数声明：移除住宿人员
void removeMember();  
// 核心功能函数声明：模糊查询寝室
void searchDorm();    
// 核心功能函数声明：排序寝室（参数为比较函数指针）
void sortDorms(int (*cmp)(Dorm_t, Dorm_t));  
// 比较函数声明：按卫生评分排序
int cmpByCleanScore(Dorm_t a, Dorm_t b);  
// 比较函数声明：按容量排序
int cmpByCapacity(Dorm_t a, Dorm_t b);    

// 工具函数：清除输入缓冲区（解决scanf输入后残留换行符的问题）
void clearInputBuffer() {
    int ch;  // 临时变量存储输入字符
    // 循环读取缓冲区字符，直到遇到换行符或文件结束符
    while ((ch = getchar()) != '\n' && ch != EOF);
}

// 功能函数：显示所有寝室信息
void showAllDorms() {
    int i;  // 循环变量（提前声明以兼容C89标准）
    // 如果没有寝室信息，提示并返回
    if (dormCount == 0) {
        printf("无寝室信息!\n");
        return;
    }
    // 打印表头
    printf("寝室号\t楼栋\t容量\t当前人数\t卫生评分\t状态\n");
    // 循环遍历所有寝室，打印信息
    for (i = 0; i < dormCount; i++) {
        printf("%s\t%s\t%d\t%d\t\t%.1f\t\t%s\n",
               dorms[i].dormNum,       // 寝室号
               dorms[i].building,      // 楼栋
               dorms[i].capacity,      // 容量
               dorms[i].currentCount,  // 当前人数
               dorms[i].cleanScore,    // 卫生评分（保留1位小数）
               dorms[i].status);       // 状态
    }
}

// 功能函数：显示指定寝室的住宿人员
void showDormMembers(char *dormNum) {
    // 调用isDormExist获取寝室索引，不存在则返回-1
    int index = isDormExist(dormNum);
    int i;  // 循环变量（提前声明以兼容C89标准）
    // 如果寝室不存在，提示并返回
    if (index == -1) {
        printf("寝室不存在!\n");
        return;
    }
    // 通过索引获取寝室指针（简化后续代码）
    Dorm_t *dorm = &dorms[index];
    // 打印寝室标识
    printf("\n【%s %s】住宿人员列表：\n", dorm->building, dorm->dormNum);
    // 如果寝室无人居住，提示并返回
    if (dorm->currentCount == 0) {
        printf("该寝室暂无住宿人员\n");
        return;
    }
    // 打印表头
    printf("学号\t姓名\n");
    // 循环遍历所有住宿人员，打印信息
    for (i = 0; i < dorm->currentCount; i++) {
        printf("%s\t%s\n", dorm->members[i].num, dorm->members[i].name);
    }
}

// 功能函数：判断寝室号是否存在（返回索引，不存在返回-1）
int isDormExist(char *dormNum) {
    int i;  // 循环变量（提前声明以兼容C89标准）
    // 遍历所有寝室，比较寝室号
    for (i = 0; i < dormCount; i++) {
        // 如果寝室号相同（strcmp返回0），返回当前索引
        if (strcmp(dorms[i].dormNum, dormNum) == 0) {
            return i;
        }
    }
    // 遍历结束未找到，返回-1
    return -1;
}

// 菜单函数：主菜单（返回-1表示退出程序，其他返回0继续运行）
int mainMenu(void *arg) {
    int choice;  // 存储用户选择的菜单选项
    // 打印主菜单内容
    printf("\n===== 寝室管理系统 =====");
    printf("\n1. 寝室信息管理（增删改）");
    printf("\n2. 住宿人员管理");
    printf("\n3. 统计与查询");
    printf("\n4. 文件操作（导入/导出）");
    printf("\n9. 退出系统");
    printf("\n请选择操作：");
    
    // 读取用户输入的选项（如果输入非数字，提示错误）
    if (scanf("%d", &choice) != 1) {
        printf("输入无效，请输入数字!\n");
        clearInputBuffer();  // 清除缓冲区残留内容
        return 0;  // 返回0表示继续运行
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 根据用户选择切换菜单或退出
    switch (choice) {
        case 1: currentMenu = menu1; break;  // 切换到菜单1
        case 2: currentMenu = menu2; break;  // 切换到菜单2
        case 3: currentMenu = menu3; break;  // 切换到菜单3
        case 4: currentMenu = menu4; break;  // 切换到菜单4
        case 9: return -1;  // 返回-1表示退出程序
        default: printf("无效选项，请重新输入!\n");  // 无效选项提示
    }
    return 0;  // 返回0表示继续运行
}

// 菜单函数：菜单1（寝室信息管理）
int menu1(void *arg) {
    int choice;  // 存储用户选择的菜单选项
    // 打印菜单1内容
    printf("\n===== 寝室信息管理 =====");
    printf("\n1. 添加新寝室");
    printf("\n2. 修改寝室信息（卫生评分/状态等）");
    printf("\n3. 删除寝室");
    printf("\n4. 查看所有寝室");
    printf("\n9. 返回主菜单");
    printf("\n请选择操作：");
    
    // 读取用户输入的选项（如果输入非数字，提示错误）
    if (scanf("%d", &choice) != 1) {
        printf("输入无效，请输入数字!\n");
        clearInputBuffer();  // 清除缓冲区残留内容
        return 0;  // 返回0表示继续运行
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 根据用户选择执行对应功能或返回主菜单
    switch (choice) {
        case 1: addDorm(); break;       // 调用添加寝室函数
        case 2: updateDorm(); break;    // 调用修改寝室函数
        case 3: deleteDorm(); break;    // 调用删除寝室函数
        case 4: showAllDorms(); break;  // 调用显示所有寝室函数
        case 9: currentMenu = mainMenu; break;  // 切换回主菜单
        default: printf("无效选项，请重新输入!\n");  // 无效选项提示
    }
    return 0;  // 返回0表示继续运行
}

// 功能函数：添加新寝室
void addDorm() {
    // 如果当前寝室数量已达最大值，提示并返回
    if (dormCount >= MAX_DORMS) {
        printf("已达最大寝室数量，无法添加!\n");
        return;
    }
    Dorm_t newDorm;  // 定义新寝室结构体变量
    // 输入寝室号
    printf("请输入寝室号（如301）：");
    if (scanf("%5s", newDorm.dormNum) != 1) {  // 最多读取5个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 检查寝室号是否已存在，存在则提示并返回
    if (isDormExist(newDorm.dormNum) != -1) {
        printf("该寝室号已存在!\n");
        return;
    }
    
    // 输入楼栋
    printf("请输入楼栋（只输入数字）：");
    if (scanf("%3s", newDorm.building) != 1) {  // 最多读取3个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 输入寝室容量
    printf("请输入寝室容量（如4、6）：");
    // 校验输入是否为有效整数，且在1到MAX_STUDENTS_PER_DORM之间
    if (scanf("%d", &newDorm.capacity) != 1 || newDorm.capacity <= 0 || newDorm.capacity > MAX_STUDENTS_PER_DORM) {
        printf("容量需为1-%d之间的整数!\n", MAX_STUDENTS_PER_DORM);
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 初始化新寝室的其他属性
    newDorm.currentCount = 0;  // 初始无住宿人员
    newDorm.cleanScore = 0.0;  // 初始卫生评分为0
    strcpy(newDorm.status, "空闲");  // 初始状态为空闲
    
    // 将新寝室添加到数组，当前寝室数量加1
    dorms[dormCount++] = newDorm;
    printf("添加成功!\n");
}

// 功能函数：修改寝室信息
void updateDorm() {
    char dormNum[6];  // 存储要修改的寝室号
    printf("请输入要修改的寝室号：");
    if (scanf("%5s", dormNum) != 1) {  // 最多读取5个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 查找寝室索引，不存在则提示并返回
    int index = isDormExist(dormNum);
    if (index == -1) {
        printf("寝室不存在!\n");
        return;
    }
    // 通过索引获取寝室指针（简化后续代码）
    Dorm_t *dorm = &dorms[index];
    
    // 修改卫生评分
    printf("当前卫生评分：%.1f，请输入新评分（0-100）：", dorm->cleanScore);
    float score;  // 存储新评分
    // 校验输入是否为有效浮点数，且在0-100之间
    if (scanf("%f", &score) == 1 && score >= 0 && score <= 100) {
        dorm->cleanScore = score;  // 更新评分
    } else {
        printf("评分输入无效，未修改!\n");
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 修改状态
    printf("当前状态：%s，请输入新状态（空闲/未满/满员/维修中）：", dorm->status);
    char newStatus[10];  // 存储新状态
    if (scanf("%9s", newStatus) == 1) {  // 最多读取9个字符
        strcpy(dorm->status, newStatus);  // 更新状态
    } else {
        printf("状态输入无效，未修改!\n");
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    printf("修改成功!\n");
}

// 功能函数：删除寝室
void deleteDorm() {
    char dormNum[6];  // 存储要删除的寝室号
    printf("请输入要删除的寝室号：");
    if (scanf("%5s", dormNum) != 1) {  // 最多读取5个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 查找寝室索引，不存在则提示并返回
    int index = isDormExist(dormNum);
    if (index == -1) {
        printf("寝室不存在!\n");
        return;
    }
    
    int i;  // 循环变量（提前声明以兼容C89标准）
    // 移动数组元素，覆盖要删除的寝室（后面的元素依次前移）
    for (i = index; i < dormCount - 1; i++) {
        dorms[i] = dorms[i + 1];
    }
    dormCount--;  // 寝室总数减1
    printf("删除成功!\n");
}

// 菜单函数：菜单2（住宿人员管理）
int menu2(void *arg) {
    int choice;  // 存储用户选择的菜单选项
    // 打印菜单2内容
    printf("\n===== 住宿人员管理 =====");
    printf("\n1. 新增住宿人员");
    printf("\n2. 移除住宿人员");
    printf("\n3. 查看寝室成员");
    printf("\n9. 返回主菜单");
    printf("\n请选择操作：");
    
    // 读取用户输入的选项（如果输入非数字，提示错误）
    if (scanf("%d", &choice) != 1) {
        printf("输入无效，请输入数字!\n");
        clearInputBuffer();  // 清除缓冲区残留内容
        return 0;  // 返回0表示继续运行
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 根据用户选择执行对应功能或返回主菜单
    switch (choice) {
        case 1: addMember(); break;       // 调用新增住宿人员函数
        case 2: removeMember(); break;    // 调用移除住宿人员函数
        case 3: {
            char dormNum[6];
            printf("请输入要查看的寝室号：");
            scanf("%5s", dormNum);
            clearInputBuffer();
            showDormMembers(dormNum);  // 调用显示寝室成员函数
            break;
        }
        case 9: currentMenu = mainMenu; break;  // 切换回主菜单
        default: printf("无效选项，请重新输入!\n");  // 无效选项提示
    }
    return 0;  // 返回0表示继续运行
}

// 功能函数：新增住宿人员
void addMember() {
    char dormNum[6];  // 存储寝室号
    printf("请输入寝室号：");
    if (scanf("%5s", dormNum) != 1) {  // 最多读取5个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 查找寝室索引，不存在则提示并返回
    int dormIndex = isDormExist(dormNum);
    if (dormIndex == -1) {
        printf("寝室不存在!\n");
        return;
    }
    // 通过索引获取寝室指针（简化后续代码）
    Dorm_t *dorm = &dorms[dormIndex];
    
    // 检查寝室是否已满
    if (dorm->currentCount >= dorm->capacity) {
        printf("该寝室已住满（容量：%d人），无法添加!\n", dorm->capacity);
        return;
    }
    
    Stu_t newMember;  // 定义新学生结构体变量
    printf("请输入学号：");
    if (scanf("%10s", newMember.num) != 1) {  // 最多读取10个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    int i;  // 循环变量（提前声明以兼容C89标准）
    // 检查该学生是否已在寝室中
    for (i = 0; i < dorm->currentCount; i++) {
        if (strcmp(dorm->members[i].num, newMember.num) == 0) {
            printf("该学生已在该寝室中!\n");
            return;
        }
    }
    
    printf("请输入姓名：");
    if (scanf("%19s", newMember.name) != 1) {  // 最多读取19个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 将新学生添加到寝室成员列表
    dorm->members[dorm->currentCount++] = newMember;
    // 更新寝室状态
    if (dorm->currentCount == dorm->capacity) {
        strcpy(dorm->status, "满员");
    } else {
        strcpy(dorm->status, "未满");
    }
    printf("添加成功！当前住宿人数：%d/%d\n", dorm->currentCount, dorm->capacity);
}

// 功能函数：移除住宿人员
void removeMember() {
    char dormNum[6];  // 存储寝室号
    printf("请输入寝室号：");
    if (scanf("%5s", dormNum) != 1) {  // 最多读取5个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 查找寝室索引，不存在则提示并返回
    int dormIndex = isDormExist(dormNum);
    if (dormIndex == -1) {
        printf("寝室不存在!\n");
        return;
    }
    // 通过索引获取寝室指针（简化后续代码）
    Dorm_t *dorm = &dorms[dormIndex];
    
    // 检查寝室是否为空
    if (dorm->currentCount == 0) {
        printf("该寝室暂无住宿人员!\n");
        return;
    }
    
    char stuNum[11];  // 存储要移除的学生学号
    printf("请输入要移除的学生学号：");
    if (scanf("%10s", stuNum) != 1) {  // 最多读取10个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    int i, stuIndex = -1;  // 循环变量（提前声明以兼容C89标准）
    // 查找学生在寝室中的位置
    for (i = 0; i < dorm->currentCount; i++) {
        if (strcmp(dorm->members[i].num, stuNum) == 0) {
            stuIndex = i;
            break;
        }
    }
    // 如果未找到学生，提示并返回
    if (stuIndex == -1) {
        printf("该学生不在此寝室中!\n");
        return;
    }
    
    // 移除学生（移动后续元素覆盖）
    for (i = stuIndex; i < dorm->currentCount - 1; i++) {
        dorm->members[i] = dorm->members[i + 1];
    }
    dorm->currentCount--;  // 当前人数减1
    
    // 更新寝室状态
    if (dorm->currentCount == 0) {
        strcpy(dorm->status, "空闲");
    } else {
        strcpy(dorm->status, "未满");
    }
    printf("移除成功！当前住宿人数：%d/%d\n", dorm->currentCount, dorm->capacity);
}

// 菜单函数：菜单3（统计与查询）
int menu3(void *arg) {
    int choice;  // 存储用户选择的菜单选项
    // 打印菜单3内容
    printf("\n===== 统计与查询 =====");
    printf("\n1. 按卫生评分排序");
    printf("\n2. 按容量排序");
    printf("\n3. 模糊查询（按楼栋/寝室号）");
    printf("\n4. 统计各楼栋寝室数量");
    printf("\n5. 统计各状态寝室数量");
    printf("\n9. 返回主菜单");
    printf("\n请选择操作：");
    
    // 读取用户输入的选项（如果输入非数字，提示错误）
    if (scanf("%d", &choice) != 1) {
        printf("输入无效，请输入数字!\n");
        clearInputBuffer();  // 清除缓冲区残留内容
        return 0;  // 返回0表示继续运行
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 根据用户选择执行对应功能或返回主菜单
    switch (choice) {
        case 1:
            sortDorms(cmpByCleanScore);  // 按卫生评分排序
            printf("\n按卫生评分从高到低排序：\n");
            showAllDorms();  // 显示所有寝室
            break;
        case 2:
            sortDorms(cmpByCapacity);  // 按容量排序
            printf("\n按容量从大到小排序：\n");
            showAllDorms();  // 显示所有寝室
            break;
        case 3:
            searchDorm();  // 模糊查询寝室
            break;
        case 4: {
            // 统计各楼栋寝室数量
            char buildings[10][4] = {0};  // 最多记录10个不同楼栋
            int buildingCounts[10] = {0};  // 对应各楼栋的寝室数量
            int buildingCount = 0;  // 不同楼栋的数量
            int i, j;  // 循环变量（提前声明以兼容C89标准）
            
            // 遍历所有寝室，统计各楼栋数量
            for (i = 0; i < dormCount; i++) {
                int found = 0;  // 标记是否已记录该楼栋
                // 检查当前楼栋是否已在记录中
                for (j = 0; j < buildingCount; j++) {
                    if (strcmp(dorms[i].building, buildings[j]) == 0) {
                        buildingCounts[j]++;  // 对应楼栋数量加1
                        found = 1;
                        break;
                    }
                }
                // 如果未记录该楼栋且还有空间，则添加到记录中
                if (!found && buildingCount < 10) {
                    strcpy(buildings[buildingCount], dorms[i].building);
                    buildingCounts[buildingCount] = 1;
                    buildingCount++;
                }
            }
            
            // 输出统计结果
            printf("\n各楼栋寝室数量统计：\n");
            for (i = 0; i < buildingCount; i++) {
                printf("%s: %d间\n", buildings[i], buildingCounts[i]);
            }
            break;
        }
        case 5: {
            // 统计各状态寝室数量
            int statusCounts[4] = {0};  // 分别存储空闲、未满、满员、维修中的寝室数量
            int i;  // 循环变量（提前声明以兼容C89标准）
            // 遍历所有寝室，统计各状态数量
            for (i = 0; i < dormCount; i++) {
                if (strcmp(dorms[i].status, "空闲") == 0) {
                    statusCounts[0]++;
                } else if (strcmp(dorms[i].status, "未满") == 0) {
                    statusCounts[1]++;
                } else if (strcmp(dorms[i].status, "满员") == 0) {
                    statusCounts[2]++;
                } else if (strcmp(dorms[i].status, "维修中") == 0) {
                    statusCounts[3]++;
                }
            }
            
            // 输出统计结果
            printf("\n各状态寝室数量统计：\n");
            printf("空闲: %d间\n", statusCounts[0]);
            printf("未满: %d间\n", statusCounts[1]);
            printf("满员: %d间\n", statusCounts[2]);
            printf("维修中: %d间\n", statusCounts[3]);
            break;
        }
        case 9:
            currentMenu = mainMenu;  // 切换回主菜单
            break;
        default:
            printf("无效选项，请重新输入!\n");  // 无效选项提示
    }
    return 0;  // 返回0表示继续运行
}

// 菜单函数：菜单4（文件操作）
int menu4(void *arg) {
    int choice;  // 存储用户选择的菜单选项
    // 打印菜单4内容
    printf("\n===== 文件操作 =====");
    printf("\n1. 导出寝室信息到文件");
    printf("\n2. 从文件导入寝室信息");
    printf("\n9. 返回主菜单");
    printf("\n请选择操作：");
    
    // 读取用户输入的选项（如果输入非数字，提示错误）
    if (scanf("%d", &choice) != 1) {
        printf("输入无效，请输入数字!\n");
        clearInputBuffer();  // 清除缓冲区残留内容
        return 0;  // 返回0表示继续运行
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    // 根据用户选择执行对应功能或返回主菜单
    switch (choice) {
        case 1: {  // 导出寝室信息到文件
            FILE *fp = fopen("dormitories.txt", "w");  // 以写入模式打开文件
            if (!fp) {  // 检查文件是否成功打开
                printf("无法打开文件!\n");
                return 0;
            }
            
            int i, j;  // 循环变量（提前声明以兼容C89标准）
            // 遍历所有寝室，写入文件
            for (i = 0; i < dormCount; i++) {
                fprintf(fp, "%s %s %d %d %.1f %s\n",
                        dorms[i].dormNum,      // 寝室号
                        dorms[i].building,     // 楼栋
                        dorms[i].capacity,     // 容量
                        dorms[i].currentCount, // 当前人数
                        dorms[i].cleanScore,   // 卫生评分
                        dorms[i].status);      // 状态
                
                // 写入住宿人员信息
                for (j = 0; j < dorms[i].currentCount; j++) {
                    fprintf(fp, "%s %s\n", 
                            dorms[i].members[j].num,  // 学号
                            dorms[i].members[j].name); // 姓名
                }
                fprintf(fp, "END\n");  // 标记一个寝室信息结束
            }
            
            fclose(fp);  // 关闭文件
            printf("已成功导出寝室信息到 dormitories.txt\n");
            break;
        }
        case 2: {  // 从文件导入寝室信息
            FILE *fp = fopen("dormitories.txt", "r");  // 以读取模式打开文件
            if (!fp) {  // 检查文件是否成功打开
                printf("无法打开文件!\n");
                return 0;
            }
            
            dormCount = 0;  // 清空现有数据
            char line[100];  // 存储读取的行
            
            // 逐行读取文件内容
            while (dormCount < MAX_DORMS && fgets(line, sizeof(line), fp) != NULL) {
                Dorm_t newDorm;  // 定义新寝室结构体变量
                // 解析寝室基本信息
                if (sscanf(line, "%5s %3s %d %d %f %9s", 
                          newDorm.dormNum,      // 寝室号
                          newDorm.building,     // 楼栋
                          &newDorm.capacity,    // 容量
                          &newDorm.currentCount, // 当前人数
                          &newDorm.cleanScore,  // 卫生评分
                          newDorm.status) != 6) {  // 状态
                    continue;  // 格式错误，跳过
                }
                
                // 读取住宿人员信息
                newDorm.currentCount = 0;  // 重置，重新读取
                // 逐行读取，直到遇到"END"标记
                while (newDorm.currentCount < MAX_STUDENTS_PER_DORM && 
                       fgets(line, sizeof(line), fp) != NULL && 
                       strncmp(line, "END", 3) != 0) {
                    Stu_t member;  // 定义学生结构体变量
                    // 解析学生信息
                    if (sscanf(line, "%10s %19s", 
                              member.num,  // 学号
                              member.name) == 2) {  // 姓名
                        newDorm.members[newDorm.currentCount++] = member;  // 添加到成员列表
                    }
                }
                
                dorms[dormCount++] = newDorm;  // 将新寝室添加到数组
            }
            
            fclose(fp);  // 关闭文件
            printf("已成功从 dormitories.txt 导入寝室信息\n");
            break;
        }
        case 9:
            currentMenu = mainMenu;  // 切换回主菜单
            break;
        default:
            printf("无效选项，请重新输入!\n");  // 无效选项提示
    }
    return 0;  // 返回0表示继续运行
}

// 功能函数：模糊查询寝室（按楼栋或寝室号关键词）
void searchDorm() {
    char keyword[20];  // 存储查询关键词
    printf("请输入楼栋或寝室号关键词：");
    if (scanf("%19s", keyword) != 1) {  // 最多读取19个字符
        printf("输入错误!\n");
        clearInputBuffer();
        return;
    }
    clearInputBuffer();  // 清除输入后的换行符
    
    int found = 0;  // 标记是否找到匹配的寝室
    printf("查询结果：\n");
    printf("寝室号\t楼栋\t容量\t当前人数\t卫生评分\t状态\n");
    
    int i;  // 循环变量（提前声明以兼容C89标准）
    // 遍历所有寝室，查找匹配关键词的寝室
    for (i = 0; i < dormCount; i++) {
        // 如果楼栋或寝室号包含关键词
        if (strstr(dorms[i].building, keyword) != NULL || 
            strstr(dorms[i].dormNum, keyword) != NULL) {
            printf("%s\t%s\t%d\t%d\t\t%.1f\t\t%s\n",
                   dorms[i].dormNum,       // 寝室号
                   dorms[i].building,      // 楼栋
                   dorms[i].capacity,      // 容量
                   dorms[i].currentCount,  // 当前人数
                   dorms[i].cleanScore,    // 卫生评分
                   dorms[i].status);       // 状态
            found = 1;  // 标记已找到匹配项
        }
    }
    
    // 如果未找到匹配项，提示用户
    if (!found) {
        printf("未找到匹配的寝室!\n");
    }
}

// 功能函数：排序寝室（使用冒泡排序，参数为比较函数指针）
void sortDorms(int (*cmp)(Dorm_t, Dorm_t)) {
    int i, j;  // 循环变量（提前声明以兼容C89标准）
    // 冒泡排序实现
    for (i = 0; i < dormCount - 1; i++) {
        for (j = 0; j < dormCount - 1 - i; j++) {
            // 使用比较函数判断是否需要交换位置
            if (cmp(dorms[j], dorms[j + 1])) {
                Dorm_t temp = dorms[j];      // 临时变量保存当前元素
                dorms[j] = dorms[j + 1];     // 当前元素与下一个元素交换
                dorms[j + 1] = temp;         // 下一个元素赋值为临时变量
            }
        }
    }
}

// 比较函数：按卫生评分从高到低排序
int cmpByCleanScore(Dorm_t a, Dorm_t b) {
    return a.cleanScore < b.cleanScore;  // 若a的评分小于b的评分，则需要交换
}

// 比较函数：按容量从大到小排序
int cmpByCapacity(Dorm_t a, Dorm_t b) {
    return a.capacity < b.capacity;  // 若a的容量小于b的容量，则需要交换
}

// 主函数：程序入口点
int main() {
    currentMenu = mainMenu;  // 默认显示主菜单
    // 循环显示当前菜单，直到返回-1（退出）
    while (1) {
        if (currentMenu(NULL) == -1) {  // 如果返回-1，表示退出
            break;
        }
    }
    printf("程序已退出。\n");
    return 0;
}    